"""总结代理 - 负责汇总所有专家代理的分析结果并生成综合报告"""

from typing import Dict, List, Any, Optional
import time
import json
from loguru import logger

from .base_agent import BaseAgent, AgentResult, ReviewItem


class SummaryAgent(BaseAgent):
    """总结代理 - 汇总所有专家代理结果"""
    
    def __init__(self, api_client, config: Dict[str, Any], retriever=None):
        super().__init__(
            name="总结专家",
            agent_type="summary",
            api_client=api_client,
            config=config
        )
        self.retriever = retriever
    
    def get_system_prompt(self) -> str:
        """获取系统提示词"""
        return """# 建筑管理总结分析专家

你是建筑管理总结分析专家，负责基于各专家代理的分析结果生成综合性Markdown格式报告。

## 核心任务

### 1. 数据处理
- 逐一分析每个专家代理的输出结果
- 提取所有问题的description、suggestion、agent、location字段
- 对比不同专家在同一位置的发现，识别一致性和差异性

### 2. 位置信息处理（重要）
- 位置信息格式："章节名称(位置编号)"，如"项目概述(1.1.1)"
- **避免乱码显示**：确保位置信息清晰可读，不出现特殊字符乱码
- **用户友好**：使用简洁明了的章节名称，避免过长的位置描述
- **内容关联**：结合章节标题提供有意义的问题描述

### 3. 问题分析要求
- **问题描述结构化**：每个问题必须包含问题现象、影响范围、解决方案三个核心要素
- **数据支撑**：所有统计结论必须有具体数据支撑，避免空洞描述
- **表述精确**：禁止使用"存在一些问题"、"部分内容"等模糊表述
- **建议可执行**：所有建议必须具体、明确、可操作，包含具体步骤和时间要求
- **格式统一**：使用标准化的问题描述模板，确保报告一致性

## 报告结构要求

### 📋 执行摘要
- 总体风险等级（优秀/良好/合格/待改进）
- 问题统计概览（总数、严重程度分布）
- 主要关注点（3-5个关键问题）
- 整体评估

### 📊 统计分析
#### 问题统计
- 总数统计、专家对比、严重程度分析、位置分布

#### 🔴 严重问题 (P0级)
**格式要求**：每个问题使用以下标准化模板
```
##### [问题编号] 问题标题
- **发现位置**：章节名称(位置编号)
- **问题描述**：[具体问题现象，避免模糊表述]
- **影响评估**：[量化影响范围和严重程度]
- **发现专家**：[专家名称及其专业意见]
- **解决方案**：[具体可执行的步骤]
- **时间要求**：[明确的解决时间框架]
- **优先级**：P0 - 严重
```

#### 🟠 重要问题 (P1级)
**格式要求**：使用与P0级相同的标准化模板，优先级标记为P1

#### 🟡 轻微问题 (P2级)
**格式要求**：使用与P0级相同的标准化模板，优先级标记为P2

#### ℹ️ 信息提示 (P3级)
**格式要求**：使用与P0级相同的标准化模板，优先级标记为P3

### 💡 改进建议
#### 紧急整改（24小时内）
#### 短期改进（1-2周内）
#### 中期改进（1-3个月内）
#### 长期优化（3个月以上）

### 📈 综合评估

#### 评估维度
- **完整性评分** (100分)：文档结构完整性、内容覆盖度、逻辑连贯性
- **合规性评分** (100分)：法规符合度、标准执行率、违规情况
- **质量评分** (100分)：技术水平、实施质量、安全性能、持久性能

#### 评分标准
- 优秀：90分以上
- 良好：80-89分  
- 合格：60-79分
- 待改进：60分以下

#### 最终评定
- **综合得分**：[根据实际分析计算加权得分]
- **等级评定**：[根据得分确定等级]
- **主要优势**：[列出项目的主要优点]
- **主要问题**：[指出需要改进的关键问题]
- **改进建议**：[提供具体的改进措施和时间安排]
### 📝 总结建议

#### 项目现状
- **优势分析**：[列出项目的主要优势和亮点]
- **问题总结**：[系统性总结主要问题]
- **改进潜力**：[分析具体的改进空间和潜力]

#### 风险提示
- **关键风险**：[列出最需要关注的关键风险]
- **预警机制**：[建议的风险预警机制]
- **应对预案**：[针对不同风险的具体应对预案]
- **监控重点**：[需要持续监控的关键指标]

请严格按照以上要求生成详细的Markdown格式报告，确保内容详实、分析深入、建议具体可执行。"""
    
    def process(self, agent_results: List[AgentResult], context: Dict[str, Any] = None) -> AgentResult:
        """处理所有专家代理结果并生成综合报告"""
        start_time = time.time()
        
        if not agent_results:
            return self.create_result(
                success=True,
                findings=[],
                summary="无专家代理结果需要汇总",
                confidence=1.0,
                processing_time=time.time() - start_time
            )
        
        try:
            self.log_processing_start(f"汇总 {len(agent_results)} 个专家代理结果")
            
            # 预处理：限制agent_results数量，避免数据过大
            if len(agent_results) > 10:
                logger.warning(f"代理结果数量过多 ({len(agent_results)})，限制为前10个最重要的结果")
                # 按成功率和findings数量排序，优先处理重要结果
                sorted_results = sorted(
                    agent_results,
                    key=lambda x: (x.success, len(x.findings)),
                    reverse=True
                )
                agent_results = sorted_results[:10]
            
            # 如果有检索器，获取额外的上下文信息
            enhanced_context = context or {}
            if self.retriever:
                try:
                    retrieval_data = self.retriever.retrieve_data_for_agent("summary")
                    enhanced_context["retrieval_summary"] = retrieval_data.get("summary", "")[:200]  # 限制长度
                    enhanced_context["session_info"] = retrieval_data.get("session_info", {})
                except Exception as e:
                    logger.warning(f"检索器获取数据失败: {e}")
            
            # 构建汇总分析提示
            prompt = self._build_summary_prompt(agent_results, enhanced_context)
            
            # API调用前的最终数据大小检查
            system_prompt = self.get_system_prompt()
            total_chars = len(system_prompt) + len(prompt)
            logger.info(f"API请求数据大小: {total_chars} 字符")
            
            if total_chars > 12000:
                logger.warning(f"API请求数据过大 ({total_chars} 字符)，进行紧急截断")
                # 紧急截断prompt
                max_prompt_length = 12000 - len(system_prompt) - 100
                prompt = prompt[:max_prompt_length] + "\n\n[数据已紧急截断，请基于以上信息生成简要报告]"
            
            # 调用API进行综合分析，直接生成Markdown报告
            response = self.api_client.chat_completion(
                messages=[
                    {"role": "system", "content": system_prompt},
                    {"role": "user", "content": prompt}
                ],
                model=self.config.get('text_model', 'Qwen/Qwen2.5-7B-Instruct')
            )
            
            logger.info(f"API调用成功，响应长度: {len(response) if response else 0} 字符")
            
            # 生成统计信息
            statistics = self._generate_statistics(agent_results)
            
            processing_time = time.time() - start_time
            
            # 直接使用API响应作为Markdown报告，如果需要可以进行后处理
            markdown_report = self._process_markdown_response(response, statistics, agent_results)
            
            # 创建综合结果
            findings = self._create_markdown_summary_findings(statistics, agent_results)
            summary = self._generate_executive_summary_from_stats(statistics)
            confidence = self._calculate_summary_confidence(agent_results)
            
            self.log_processing_end(True, processing_time, len(findings))
            
            return self.create_result(
                success=True,
                findings=findings,
                summary=summary,
                confidence=confidence,
                processing_time=processing_time,
                metadata={
                    "agents_processed": len(agent_results),
                    "total_findings": sum(len(result.findings) for result in agent_results),
                    "statistics": statistics,
                    "agent_type": self.agent_type,
                    "enhanced_context": enhanced_context,
                    "markdown_report": markdown_report  # 直接保存Markdown报告
                }
            )
            
        except Exception as e:
            return self.handle_api_error(e, "综合分析")
    
    def _build_summary_prompt(self, agent_results: List[AgentResult], context: Dict[str, Any] = None) -> str:
        """构建汇总分析提示 - 简化版本，只传递核心字段"""
        # 提取核心字段：description、suggestion、agent、location
        extracted_findings = self._extract_core_findings(agent_results)
        
        # 构建简化的提示词
        prompt_parts = []
        
        # 添加系统提示
        prompt_parts.append("请基于以下专家分析结果，生成一份完整的Markdown格式报告。")
        prompt_parts.append("")
        
        # 直接提供核心数据
        prompt_parts.append("### 专家分析结果：")
        prompt_parts.append("")
        
        for i, finding in enumerate(extracted_findings, 1):
            prompt_parts.append(f"#### 发现 {i}")
            prompt_parts.append(f"- **问题描述**: {finding['description']}")
            prompt_parts.append(f"- **改进建议**: {finding['suggestion']}")
            prompt_parts.append(f"- **分析来源**: {finding['agent']}")
            # 简化位置信息显示，避免冗长的章节列表
            location = self._simplify_location_info(finding['location'])
            prompt_parts.append(f"- **位置信息**: {location}")
            prompt_parts.append(f"- **严重程度**: {finding['severity']}")
            prompt_parts.append("")
        
        prompt_parts.append("请基于以上数据生成完整的Markdown报告，包含执行摘要、统计分析、问题详情、改进建议和综合评估。")
        
        return "\n".join(prompt_parts)
    
    def _extract_core_findings(self, agent_results: List[AgentResult]) -> List[Dict[str, Any]]:
        """从专家结果中提取核心字段：description、suggestion、agent、location"""
        extracted_findings = []
        
        for result in agent_results:
            if not result.findings:
                continue
                
            for finding in result.findings:
                # 只提取核心字段，不做任何额外处理
                core_finding = {
                    'description': finding.get('description', ''),
                    'suggestion': finding.get('suggestion', ''),
                    'agent': finding.get('agent', result.agent_name),
                    'location': finding.get('location', ''),
                    'severity': finding.get('severity', 'minor')
                }
                
                # 只保留有效的发现（有描述和建议）
                if core_finding['description'] and core_finding['suggestion']:
                    extracted_findings.append(core_finding)
        
        return extracted_findings
    
    def _simplify_location_info(self, location: str) -> str:
        """简化位置信息，避免显示冗长的章节列表"""
        if not location:
            return "未指定位置"
        
        # 如果位置信息包含大量章节编号，进行简化
        locations = [loc.strip() for loc in location.split(',') if loc.strip()]
        
        # 过滤掉"未分类内容"
        filtered_locations = [loc for loc in locations if loc != "未分类内容"]
        
        if len(filtered_locations) == 0:
            return "文档整体"
        elif len(filtered_locations) <= 3:
            return ", ".join(filtered_locations)
        else:
            # 如果位置太多，只显示前几个并标注总数
            return f"{', '.join(filtered_locations[:2])}等{len(filtered_locations)}处"
    

    
    def _calculate_statistics(self, agent_results: List[AgentResult]) -> Dict[str, Any]:
        """计算统计信息"""
        total_findings = 0
        severity_distribution = {'critical': 0, 'major': 0, 'minor': 0}
        
        for result in agent_results:
            if result.findings:
                total_findings += len(result.findings)
                for finding in result.findings:
                    severity = finding.get('severity', 'minor')
                    if severity in severity_distribution:
                        severity_distribution[severity] += 1
        
        return {
            'total_findings': total_findings,
            'severity_distribution': severity_distribution
        }
    

    

    

    

    
    def _generate_statistics(self, agent_results: List[AgentResult]) -> Dict[str, Any]:
        """生成统计信息"""
        stats = {
            "total_agents": len(agent_results),
            "successful_agents": sum(1 for r in agent_results if r.success),
            "failed_agents": sum(1 for r in agent_results if not r.success),
            "total_findings": 0,
            "severity_distribution": {"critical": 0, "major": 0, "minor": 0, "info": 0},
            "agent_performance": [],
            "location_distribution": {},
            "category_distribution": {}
        }
        
        for result in agent_results:
            agent_stats = {
                "agent_name": result.agent_name,
                "agent_type": result.agent_type,
                "success": result.success,
                "findings_count": len(result.findings),
                "confidence": result.confidence,
                "processing_time": result.processing_time
            }
            stats["agent_performance"].append(agent_stats)
            
            stats["total_findings"] += len(result.findings)
            
            for finding in result.findings:
                # 统计严重性分布
                severity = finding.get('severity', 'info')
                if severity in stats["severity_distribution"]:
                    stats["severity_distribution"][severity] += 1
                
                # 统计位置分布
                location = finding.get('location', '未知位置')
                stats["location_distribution"][location] = stats["location_distribution"].get(location, 0) + 1
                
                # 统计类别分布
                category = finding.get('category', '未分类')
                stats["category_distribution"][category] = stats["category_distribution"].get(category, 0) + 1
        
        return stats
    

    
    def _get_location_content(self, location_str: str, session_id: str = None) -> Dict[str, Dict[str, str]]:
        """根据位置信息检索具体的章节内容"""
        location_info = {}
        
        if not location_str or not self.retriever:
            return location_info
        
        try:
            # 获取session_id
            if not session_id:
                session_id = self.retriever.data_loader.get_latest_session_id()
            
            # 解析位置字符串，可能包含多个位置
            locations = [loc.strip() for loc in location_str.split(',') if loc.strip()]
            
            for location in locations:
                # 使用数据加载器获取具体内容
                session_data = self.retriever.data_loader.load_session_data(session_id)
                if not session_data:
                    continue
                
                # 查找对应的文本分组
                for group in session_data.text_groups:
                    if group.get('level3_number') == location:
                        # 提取章节标题和内容摘要
                        elements = group.get('elements', [])
                        if elements:
                            # 找到标题元素
                            title_element = None
                            content_elements = []
                            
                            for element in elements:
                                if element.get('subcategory') == 'level3_title':
                                    title_element = element
                                else:
                                    content_elements.append(element)
                            
                            # 构建章节信息
                            if title_element:
                                title = title_element.get('content', '').strip()
                                # 清理标题，移除编号部分
                                title_clean = title
                                if title.startswith(location):
                                    title_clean = title[len(location):].strip('　 \t')
                                
                                # 获取内容摘要
                                content_summary = ""
                                if content_elements:
                                    content_texts = [elem.get('content', '') for elem in content_elements[:3]]  # 取前3个元素
                                    content_summary = " ".join(content_texts)[:200] + "..." if len(" ".join(content_texts)) > 200 else " ".join(content_texts)
                                
                                location_info[location] = {
                                    'title': title_clean,
                                    'full_title': title,
                                    'content_summary': content_summary,
                                    'element_count': len(elements)
                                }
                        break
        except Exception as e:
            logger.error(f"检索位置内容失败: {e}")
        
        return location_info
    
    def _format_location_display(self, location_str: str, location_content: Dict[str, str]) -> str:
        """格式化位置信息显示，简化处理避免乱码"""
        if not location_str:
            return "未指定位置"
        
        # 清理和分割位置字符串
        locations = [loc.strip() for loc in location_str.split(',') if loc.strip()]
        
        # 如果位置过多，进行简化显示
        if len(locations) > 5:
            return f"多个位置({len(locations)}处: {', '.join(locations[:3])}等)"
        
        # 格式化每个位置
        formatted_locations = []
        
        for location in locations:
            # 处理特殊位置
            if location in ["未分类内容", "全文", "整体"]:
                formatted_locations.append(location)
                continue
            
            # 尝试获取章节标题
            if location in location_content:
                info = location_content[location]
                title = info.get('title', '').strip()
                if title:
                    # 清理标题，移除可能的乱码字符
                    title_clean = ''.join(char for char in title if ord(char) < 65536)  # 移除高位Unicode字符
                    if title_clean:
                        formatted_locations.append(f"{title_clean}({location})")
                    else:
                        formatted_locations.append(location)
                else:
                    formatted_locations.append(location)
            else:
                formatted_locations.append(location)
        
        return ", ".join(formatted_locations)

    def _extract_key_findings_from_agents(self, agent_results: List[AgentResult]) -> List[Dict[str, Any]]:
        """从各专家代理结果中提取关键发现"""
        key_findings = []
        
        for result in agent_results:
            if not result.success or not result.findings:
                continue
                
            # 按严重性筛选关键问题
            critical_and_major_findings = [
                f for f in result.findings 
                if f.get('severity') in ['critical', 'major']
            ]
            
            for finding in critical_and_major_findings:
                key_findings.append({
                    "item_id": f"summary_key_{result.agent_type}_{finding.get('item_id', 'unknown')}",
                    "category": f"关键问题汇总-{result.agent_name}",
                    "severity": finding.get('severity', 'unknown'),
                    "description": f"【{result.agent_name}发现】{finding.get('description', '无描述')}",
                    "suggestion": finding.get('suggestion', '无建议'),
                    "confidence": finding.get('confidence', result.confidence),
                    "agent": f"{self.name}(汇总自{result.agent_name})",
                    "location": finding.get('location', '未知位置'),
                    "agent_name": self.agent_type,
                    "agent_type": self.agent_type,
                    "original_agent": result.agent_name,
                    "original_agent_type": result.agent_type
                })
        
        return key_findings
    
    def _create_summary_findings(self, summary_result: Dict[str, Any], statistics: Dict[str, Any]) -> List[Dict[str, Any]]:
        """创建汇总发现（保留原方法以兼容性）"""
        findings = []
        
        # 添加执行摘要作为发现
        exec_summary = summary_result.get('executive_summary', {})
        if exec_summary:
            findings.append({
                "item_id": "summary_001",
                "category": "执行摘要",
                "severity": "info",
                "description": exec_summary.get('overall_assessment', '综合评估结果'),
                "suggestion": "请查看详细的优先级建议和改进路径",
                "confidence": 1.0,
                "agent": self.name,
                "location": "整体项目",
                "agent_name": self.agent_type,
                "agent_type": self.agent_type
            })
        
        # 添加统计信息作为发现
        findings.append({
            "item_id": "summary_002",
            "category": "问题统计",
            "severity": "info",
            "description": f"共发现 {statistics['total_findings']} 个问题：严重 {statistics['severity_distribution']['critical']} 个，重要 {statistics['severity_distribution']['major']} 个，轻微 {statistics['severity_distribution']['minor']} 个",
            "suggestion": "优先处理严重和重要问题",
            "confidence": 1.0,
            "agent": self.name,
            "location": "整体项目",
            "agent_name": self.agent_type,
            "agent_type": self.agent_type
        })
        
        # 添加优先级建议
        priority_recs = summary_result.get('priority_recommendations', [])
        for i, rec in enumerate(priority_recs[:3]):  # 只取前3个优先级建议
            findings.append({
                "item_id": f"summary_priority_{i+1:03d}",
                "category": "优先级建议",
                "severity": "info",
                "description": f"优先级 {rec.get('priority', i+1)}: {rec.get('title', '改进建议')}",
                "suggestion": rec.get('description', '请查看详细建议'),
                "confidence": 0.9,
                "agent": self.name,
                "location": "整体项目",
                "agent_name": self.agent_type,
                "agent_type": self.agent_type
            })
        
        return findings
    
    def _generate_executive_summary(self, summary_result: Dict[str, Any], statistics: Dict[str, Any]) -> str:
        """生成执行摘要"""
        exec_summary = summary_result.get('executive_summary', {})
        
        summary_parts = [
            f"综合分析完成，共处理 {statistics['total_agents']} 个专家代理结果",
            f"发现问题总计 {statistics['total_findings']} 个",
            f"严重问题 {statistics['severity_distribution']['critical']} 个",
            f"重要问题 {statistics['severity_distribution']['major']} 个",
            f"轻微问题 {statistics['severity_distribution']['minor']} 个"
        ]
        
        overall_risk = exec_summary.get('overall_risk_level', 'medium')
        risk_desc = {
            'low': '低风险',
            'medium': '中等风险', 
            'high': '高风险',
            'critical': '严重风险'
        }.get(overall_risk, '未知风险')
        
        summary_parts.append(f"整体风险等级：{risk_desc}")
        
        return "，".join(summary_parts)
    
    def _calculate_summary_confidence(self, agent_results: List[AgentResult]) -> float:
        """计算汇总置信度"""
        if not agent_results:
            return 0.0
        
        successful_agents = [r for r in agent_results if r.success]
        if not successful_agents:
            return 0.0
        
        # 基于成功代理数量和平均置信度
        success_rate = len(successful_agents) / len(agent_results)
        avg_confidence = sum(r.confidence for r in successful_agents) / len(successful_agents)
        
        return min(success_rate * avg_confidence, 1.0)
    
    def _generate_text_report(self, summary_result: Dict[str, Any], statistics: Dict[str, Any], agent_results: List[AgentResult]) -> str:
        """生成用户友好的文本格式报告"""
        from datetime import datetime
        
        report_lines = []
        
        # 报告标题和时间
        report_lines.append("="*60)
        report_lines.append("AIDA 智能文档分析报告")
        report_lines.append("="*60)
        report_lines.append(f"生成时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        report_lines.append(f"分析代理数量: {len(agent_results)}")
        report_lines.append("")
        
        # 执行摘要
        report_lines.append("📋 执行摘要")
        report_lines.append("-"*30)
        exec_summary = summary_result.get('executive_summary', {})
        if isinstance(exec_summary, dict):
            report_lines.append(f"• 总体风险等级: {exec_summary.get('overall_risk_level', '未知')}")
            report_lines.append(f"• 处理状态: {exec_summary.get('processing_status', '未知')}")
            report_lines.append(f"• 主要关注点: {exec_summary.get('key_concerns', '无')}")
        else:
            report_lines.append(f"• {exec_summary}")
        report_lines.append("")
        
        # 统计信息 - 重新计算准确的问题数量
        report_lines.append("📊 统计信息")
        report_lines.append("-"*30)
        
        # 重新统计各严重程度的问题数量
        severity_counts = {"critical": 0, "major": 0, "minor": 0, "info": 0}
        total_actual_issues = 0
        
        for result in agent_results:
            if result.success and result.findings:
                for finding in result.findings:
                    total_actual_issues += 1
                    severity = finding.get('severity', 'info').lower()
                    # 标准化严重程度名称
                    if severity in ['critical', 'high']:
                        severity_counts['critical'] += 1
                    elif severity in ['major', 'important']:
                        severity_counts['major'] += 1
                    elif severity in ['minor', 'medium', 'low']:
                        severity_counts['minor'] += 1
                    else:
                        severity_counts['info'] += 1
        
        report_lines.append(f"• 发现问题总数: {total_actual_issues}")
        
        if total_actual_issues > 0:
            report_lines.append("• 问题严重程度分布:")
            severity_labels = {
                'critical': '严重问题',
                'major': '重要问题', 
                'minor': '轻微问题',
                'info': '信息提示'
            }
            for severity, count in severity_counts.items():
                if count > 0:
                    report_lines.append(f"  - {severity_labels[severity]}: {count} 个")
        
        agent_stats = statistics.get('agent_performance', [])
        if agent_stats:
            successful_agents = sum(1 for perf in agent_stats if perf.get('success', False))
            report_lines.append(f"• 成功执行的代理: {successful_agents}/{len(agent_stats)}")
        
        report_lines.append("")
        
        # 主要发现
        report_lines.append("🔍 主要发现")
        report_lines.append("-"*30)
        
        # 按严重程度分类显示问题
        severity_order = ['critical', 'major', 'minor', 'info']
        severity_names = {
            'critical': '🔴 严重问题',
            'major': '🟠 重要问题', 
            'minor': '🟡 轻微问题',
            'info': 'ℹ️ 信息提示'
        }
        
        findings_by_severity = {}
        for result in agent_results:
            if result.success and result.findings:
                for finding in result.findings:
                    severity = finding.get('severity', 'info').lower()
                    if severity not in findings_by_severity:
                        findings_by_severity[severity] = []
                    findings_by_severity[severity].append({
                        'agent': result.agent_type,
                        'finding': finding
                    })
        
        for severity in severity_order:
            if severity in findings_by_severity:
                report_lines.append(f"\n{severity_names.get(severity, severity.upper())}（{len(findings_by_severity[severity])}个）：")
                report_lines.append("-" * 30)
                
                finding_count = 1
                for item in findings_by_severity[severity][:5]:  # 限制每个级别最多5个
                    finding = item['finding']
                    agent = item['agent']
                    category = finding.get('category', '未分类')
                    description = finding.get('description', '无描述')
                    suggestion = finding.get('suggestion', '')
                    location = finding.get('location', '未知位置')
                    confidence = finding.get('confidence', 0)
                    
                    # 清理描述和建议中的JSON片段
                    clean_description = self._clean_json_content(description)
                    clean_suggestion = self._clean_json_content(suggestion)
                    
                    # 如果清理后内容为空，使用默认描述
                    if not clean_description or clean_description == "详细信息请参考原始分析结果":
                        clean_description = f"{category}相关问题需要关注"
                    
                    if not clean_suggestion or clean_suggestion == "详细信息请参考原始分析结果":
                        clean_suggestion = "建议进一步检查和优化"
                    
                    report_lines.extend([
                        f"{finding_count}. 【{category}】- 来源：{agent}",
                        f"   📋 问题描述：{clean_description}",
                        f"   💡 改进建议：{clean_suggestion}",
                        f"   📍 位置信息：{location}",
                        f"   🎯 置信度：{confidence:.1f}" if isinstance(confidence, (int, float)) else f"   🎯 置信度：{confidence}",
                        ""
                    ])
                    finding_count += 1
        
        if not findings_by_severity:
            report_lines.append("✅ 未发现明显问题")
        
        report_lines.append("")
        
        # 改进建议
        report_lines.append("💡 改进建议")
        report_lines.append("-"*30)
        
        recommendations = summary_result.get('priority_recommendations', [])
        if recommendations:
            for i, rec in enumerate(recommendations[:5], 1):  # 最多显示5个建议
                if isinstance(rec, dict):
                    action = rec.get('action', '未指定操作')
                    priority = rec.get('priority', '中等')
                    timeline = rec.get('timeline', '未指定时间')
                    
                    # 清理建议中的JSON片段
                    clean_action = self._clean_json_content(action)
                    
                    report_lines.append(f"{i}. {clean_action}")
                    report_lines.append(f"   🎯 优先级: {priority} | ⏰ 建议时间: {timeline}")
                else:
                    clean_rec = self._clean_json_content(str(rec))
                    report_lines.append(f"{i}. {clean_rec}")
                report_lines.append("")
        else:
            # 基于发现的问题生成具体建议
            if severity_counts['critical'] > 0:
                report_lines.append("🔴 紧急建议（严重问题）:")
                report_lines.append("• 立即组织专项小组处理严重问题")
                report_lines.append("• 暂停相关业务流程直至问题解决")
                report_lines.append("• 建立问题跟踪和汇报机制")
                report_lines.append("")
            
            if severity_counts['major'] > 0:
                report_lines.append("🟠 重要建议（重要问题）:")
                report_lines.append("• 制定详细的问题解决计划和时间表")
                report_lines.append("• 分配专门资源处理重要问题")
                report_lines.append("• 建立定期检查和进度汇报")
                report_lines.append("")
            
            if severity_counts['minor'] > 0:
                report_lines.append("🟡 一般建议（轻微问题）:")
                report_lines.append("• 纳入日常维护和改进计划")
                report_lines.append("• 安排合适的时间窗口进行优化")
                report_lines.append("• 考虑批量处理类似问题")
                report_lines.append("")
            
            if total_actual_issues == 0:
                report_lines.append("✅ 质量保持建议:")
                report_lines.append("• 继续保持当前的良好实践")
                report_lines.append("• 建立定期质量检查机制")
                report_lines.append("• 考虑进一步提升标准和流程")
                report_lines.append("")
        
        # 下一步行动
        report_lines.append("🎯 下一步行动")
        report_lines.append("-"*30)
        
        next_steps = summary_result.get('next_steps', [])
        if next_steps:
            for i, step in enumerate(next_steps[:3], 1):  # 最多显示3个步骤
                clean_step = self._clean_json_content(str(step))
                report_lines.append(f"{i}. {clean_step}")
        else:
            # 基于问题严重程度生成具体行动计划
            action_count = 1
            
            if severity_counts['critical'] > 0:
                report_lines.append(f"{action_count}. 🚨 立即行动（24小时内）:")
                report_lines.append("   • 召集紧急会议，评估严重问题影响范围")
                report_lines.append("   • 制定应急处理方案和回滚计划")
                report_lines.append("   • 指派专人负责问题跟踪和沟通")
                action_count += 1
                report_lines.append("")
            
            if severity_counts['major'] > 0:
                report_lines.append(f"{action_count}. 📋 短期行动（1-2周内）:")
                report_lines.append("   • 制定重要问题的详细解决方案")
                report_lines.append("   • 分配相应资源和责任人")
                report_lines.append("   • 建立问题解决进度跟踪机制")
                action_count += 1
                report_lines.append("")
            
            if severity_counts['minor'] > 0:
                report_lines.append(f"{action_count}. 📅 中期行动（1个月内）:")
                report_lines.append("   • 将轻微问题纳入常规维护计划")
                report_lines.append("   • 安排合适的处理时间窗口")
                report_lines.append("   • 考虑批量优化和改进")
                action_count += 1
                report_lines.append("")
            
            # 通用后续行动
            report_lines.append(f"{action_count}. 🔄 持续改进:")
            if total_actual_issues > 0:
                report_lines.append("   • 建立问题解决后的验证机制")
                report_lines.append("   • 安排定期复查和质量评估")
                report_lines.append("   • 总结经验教训，完善预防措施")
            else:
                report_lines.append("   • 建立定期质量检查制度")
                report_lines.append("   • 持续监控和改进现有流程")
                report_lines.append("   • 探索更高标准的质量要求")
        
        report_lines.append("")
        report_lines.append("="*60)
        report_lines.append("报告结束")
        report_lines.append("="*60)
        
        return "\n".join(report_lines)
    
    def _process_markdown_response(self, response, statistics, agent_results):
        """直接返回大模型的原始输出，不做任何处理"""
        # 直接返回大模型的原始输出，不做任何额外处理
        if not response:
            # 如果大模型没有返回内容，使用备用报告
            return self._generate_fallback_markdown_report(statistics, agent_results)
        
        return response.strip()
    
    def _generate_direct_markdown_report(self, statistics, agent_results):
        """直接生成完整的Markdown报告"""
        from datetime import datetime
        
        # 提取核心发现
        core_findings = self._extract_core_findings(agent_results)
        
        # 按严重程度分组
        grouped_findings = {
            'critical': [f for f in core_findings if f.get('severity') == 'critical'],
            'major': [f for f in core_findings if f.get('severity') == 'major'],
            'minor': [f for f in core_findings if f.get('severity') == 'minor']
        }
        
        # 计算统计信息
        stats = self._calculate_statistics(agent_results)
        critical_count = stats['severity_distribution']['critical']
        major_count = stats['severity_distribution']['major']
        minor_count = stats['severity_distribution']['minor']
        total_findings = stats['total_findings']
        
        # 计算百分比
        critical_percentage = (critical_count / total_findings * 100) if total_findings > 0 else 0
        major_percentage = (major_count / total_findings * 100) if total_findings > 0 else 0
        minor_percentage = (minor_count / total_findings * 100) if total_findings > 0 else 0
        
        report = []
        report.append("# AIDA 智能文档分析综合报告")
        report.append("")
        report.append(f"**生成时间**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        report.append("")
        
        # 执行摘要
        report.append("## 📊 执行摘要")
        report.append(f"本次分析共处理了 {stats['total_agents']} 个专业代理，")
        report.append(f"发现了 {total_findings} 个问题。")
        report.append(f"其中严重问题 {critical_count} 个，")
        report.append(f"重要问题 {major_count} 个，")
        report.append(f"轻微问题 {minor_count} 个。")
        report.append("")
        
        # 统计分析
        report.append("## 📈 统计分析")
        report.append(f"- **总计问题数**: {total_findings}")
        report.append(f"- **严重问题**: {critical_count} ({critical_percentage:.1f}%)")
        report.append(f"- **重要问题**: {major_count} ({major_percentage:.1f}%)")
        report.append(f"- **轻微问题**: {minor_count} ({minor_percentage:.1f}%)")
        report.append(f"- **成功执行代理**: {stats['successful_agents']}/{stats['total_agents']}")
        report.append("")
        
        # 严重问题
        report.append("### 🔴 严重问题 (P0级)")
        report.append("")
        if grouped_findings['critical']:
            for i, finding in enumerate(grouped_findings['critical'], 1):
                report.append(f"**问题 {i}: {finding['description']}**")
                report.append(f"- **改进建议**: {finding['suggestion']}")
                report.append(f"- **检测代理**: {finding['agent']}")
                if finding.get('location'):
                    report.append(f"- **相关位置**: {finding['location']}")
                report.append(f"- **置信度**: {finding.get('confidence', 0.8):.1%}")
                report.append("")
        else:
            report.append("暂未发现严重问题。")
            report.append("")
        
        # 重要问题
        report.append("### 🟠 重要问题 (P1级)")
        report.append("")
        if grouped_findings['major']:
            for i, finding in enumerate(grouped_findings['major'], 1):
                report.append(f"**问题 {i}: {finding['description']}**")
                report.append(f"- **改进建议**: {finding['suggestion']}")
                report.append(f"- **检测代理**: {finding['agent']}")
                if finding.get('location'):
                    report.append(f"- **相关位置**: {finding['location']}")
                report.append(f"- **置信度**: {finding.get('confidence', 0.8):.1%}")
                report.append("")
        else:
            report.append("暂未发现重要问题。")
            report.append("")
        
        # 轻微问题
        report.append("### 🟡 轻微问题 (P2级)")
        report.append("")
        if grouped_findings['minor']:
            for i, finding in enumerate(grouped_findings['minor'], 1):
                report.append(f"**问题 {i}: {finding['description']}**")
                report.append(f"- **改进建议**: {finding['suggestion']}")
                report.append(f"- **检测代理**: {finding['agent']}")
                if finding.get('location'):
                    report.append(f"- **相关位置**: {finding['location']}")
                report.append(f"- **置信度**: {finding.get('confidence', 0.8):.1%}")
                report.append("")
        else:
            report.append("暂未发现轻微问题。")
            report.append("")
        
        # 改进建议
        report.append("## 💡 改进建议")
        if critical_count > 0:
            report.append("**优先级1 - 立即处理严重问题**:")
            report.append("- 严重问题可能影响文档的核心质量和可读性")
            report.append("- 建议立即制定修复计划并优先处理")
            report.append("")
        
        if major_count > 0:
            report.append("**优先级2 - 及时处理重要问题**:")
            report.append("- 重要问题影响文档的整体质量")
            report.append("- 建议在处理完严重问题后及时跟进")
            report.append("")
        
        if minor_count > 0:
            report.append("**优先级3 - 逐步优化轻微问题**:")
            report.append("- 轻微问题可在时间允许时逐步优化")
            report.append("- 有助于提升文档的整体完善度")
            report.append("")
        
        # 综合评估
        report.append("## 🎯 综合评估")
        if total_findings == 0:
            report.append("文档质量良好，未发现明显问题。")
        elif critical_count == 0 and major_count <= 2:
            report.append("文档整体质量较好，存在少量可优化的地方。")
        elif critical_count <= 2:
            report.append("文档质量中等，建议重点关注严重和重要问题的修复。")
        else:
            report.append("文档存在较多问题，建议制定系统性的改进计划。")
        
        report.append("")
        report.append("---")
        report.append(f"*报告生成时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*")
        
        return "\n".join(report)
    
    def _generate_fallback_markdown_report(self, statistics, agent_results):
        """生成备用的Markdown报告"""
        from datetime import datetime
        
        report = []
        report.append("# AIDA 智能文档分析综合报告")
        report.append("")
        report.append(f"**生成时间**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        report.append("")
        
        # 执行摘要
        report.append("## 执行摘要")
        report.append(f"本次分析共处理了 {statistics['total_agents']} 个专业代理，")
        report.append(f"发现了 {statistics['total_findings']} 个问题，")
        report.append(f"其中严重问题 {statistics['severity_distribution'].get('critical', 0)} 个，")
        report.append(f"重要问题 {statistics['severity_distribution'].get('major', 0)} 个。")
        report.append("")
        
        # 主要发现
        report.append("## 主要发现")
        for agent_result in agent_results:
            if agent_result.findings:
                report.append(f"### {agent_result.agent_name}")
                for finding in agent_result.findings[:3]:  # 只显示前3个发现
                    report.append(f"- **{finding.get('severity', '未知')}**: {finding.get('description', '无描述')}")
                report.append("")
        
        # 改进建议
        report.append("## 改进建议")
        report.append("基于分析结果，建议优先处理严重和重要级别的问题，")
        report.append("并制定相应的改进计划。")
        report.append("")
        
        return "\n".join(report)
    
    def _create_markdown_summary_findings(self, statistics, agent_results):
        """创建简化的发现列表，用于兼容性"""
        findings = []
        
        # 添加统计信息作为发现
        findings.append({
            "item_id": "summary_001",
            "category": "统计信息",
            "severity": "info",
            "description": f"共处理 {statistics['total_agents']} 个代理，发现 {statistics['total_findings']} 个问题",
            "suggestion": "请查看详细分析结果",
            "confidence": 1.0,
            "agent": self.name,
            "location": "整体项目",
            "agent_name": self.agent_type,
            "agent_type": self.agent_type
        })
        
        # 添加主要问题
        for agent_result in agent_results:
            for finding in agent_result.findings[:2]:  # 每个代理最多2个发现
                findings.append(finding)
        
        return findings[:10]  # 最多返回10个发现
    
    def _generate_executive_summary_from_stats(self, statistics):
        """基于统计信息生成执行摘要"""
        return f"分析了 {statistics['total_agents']} 个专业领域，发现 {statistics['total_findings']} 个问题，需要重点关注严重和重要级别的问题。"
    
    def _get_location_content(self, location: str, session_id: str = None) -> Dict[str, Dict[str, str]]:
        """根据位置信息获取章节内容"""
        location_content_map = {}
        
        if not location or not session_id:
            return location_content_map
        
        try:
            from ..utils.data_loader import DataLoader
            data_loader = DataLoader()
            session_data = data_loader.load_session_data(session_id)
            
            if not session_data or not session_data.text_groups:
                return location_content_map
            
            # 解析位置信息
            locations = [loc.strip() for loc in location.split(',') if loc.strip()]
            
            for loc in locations:
                # 查找对应的level3_groups
                for group in session_data.text_groups:
                    if group.get('level3_number') == loc:
                        # 提取章节标题和内容摘要
                        title = "未知章节"
                        content_summary = ""
                        
                        for element in group.get('elements', []):
                            if element.get('subcategory') == 'level3_title':
                                title = element.get('content', '未知章节')
                                break
                        
                        # 收集内容摘要
                        content_parts = []
                        for element in group.get('elements', []):
                            if element.get('category') == 'text' and element.get('content'):
                                content = element.get('content', '').strip()
                                if content and len(content) > 10:  # 过滤太短的内容
                                    content_parts.append(content[:100])  # 限制长度
                        
                        content_summary = ' '.join(content_parts[:3])  # 最多3个内容片段
                        
                        location_content_map[loc] = {
                            'title': title,
                            'content_summary': content_summary
                        }
                        break
                        
        except Exception as e:
            logger.warning(f"获取位置内容失败: {e}")
            
        return location_content_map
    
    def _format_location_display(self, location: str, location_content_map: Dict[str, Dict[str, str]]) -> str:
        """格式化位置信息显示"""
        if not location:
            return "未知位置"
        
        # 解析位置信息
        locations = [loc.strip() for loc in location.split(',') if loc.strip()]
        formatted_locations = []
        
        for loc in locations:
            if loc in location_content_map:
                title = location_content_map[loc].get('title', '未知章节')
                # 清理标题中的编号前缀
                clean_title = title
                if title.startswith(loc):
                    clean_title = title[len(loc):].strip('　 \t-')
                formatted_locations.append(f"{clean_title}({loc})")
            else:
                formatted_locations.append(loc)
        
        return ', '.join(formatted_locations)